import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 专业组匹配测试类
 * 用于验证MajorAdmissionInfo中的subjectGroup与CollegeEnrollmentPlan中的specialGroupName的匹配逻辑
 */
public class 专业组匹配测试 {
    
    public static void main(String[] args) {
        专业组匹配测试 test = new 专业组匹配测试();
        test.testSpecialGroupMatching();
    }
    
    public void testSpecialGroupMatching() {
        System.out.println("=== 专业组匹配测试 ===");
        
        // 模拟已有专业的专业组数据（MajorAdmissionInfo格式）
        Set<String> existingSchoolSpecialGroups = new HashSet<>();
        existingSchoolSpecialGroups.add("北京大学::1093（W003）");
        existingSchoolSpecialGroups.add("清华大学::1094（W001）");
        existingSchoolSpecialGroups.add("复旦大学::1095（W002）");
        existingSchoolSpecialGroups.add("上海交通大学::1096（003）");
        existingSchoolSpecialGroups.add("浙江大学::1097（L001）");
        existingSchoolSpecialGroups.add("中山大学::1098（W005）");  // 新增测试用例
        
        System.out.println("已有专业组数据:");
        existingSchoolSpecialGroups.forEach(System.out::println);
        System.out.println();
        
        // 测试用例：招生计划中的专业组格式（CollegeEnrollmentPlan格式）
        String[][] testCases = {
            {"北京大学", "（W003）", "true"},   // 应该匹配 1093（W003）
            {"北京大学", "（003）", "true"},   // 应该匹配 1093（W003），数字部分相同
            {"清华大学", "（W001）", "true"},   // 应该匹配 1094（W001）
            {"清华大学", "（001）", "true"},   // 应该匹配 1094（W001），数字部分相同
            {"复旦大学", "（W002）", "true"},   // 应该匹配 1095（W002）
            {"复旦大学", "（002）", "true"},   // 应该匹配 1095（W002），数字部分相同
            {"上海交通大学", "（003）", "true"},   // 应该匹配 1096（003）
            {"上海交通大学", "（W003）", "true"},  // 应该匹配 1096（003），数字部分相同
            {"浙江大学", "（L001）", "true"},   // 应该匹配 1097（L001）
            {"浙江大学", "（001）", "true"},   // 应该匹配 1097（L001），数字部分相同
            {"中山大学", "（005）", "true"},   // 应该匹配 1098（W005），数字部分相同
            {"中山大学", "（W005）", "true"},  // 应该匹配 1098（W005）
            {"中山大学", "（W003）", "false"},  // 数字部分不匹配
            {"北京大学", "（W999）", "false"},  // 专业组编号不匹配
            {"北京大学", "(W003)", "true"},    // 英文括号格式
            {"北京大学", "W003", "true"},      // 无括号格式
            {"北京大学", "003", "true"},       // 纯数字格式，应该匹配W003
        };
        
        System.out.println("测试结果:");
        int passCount = 0;
        int totalCount = testCases.length;
        
        for (String[] testCase : testCases) {
            String schoolName = testCase[0];
            String specialGroupName = testCase[1];
            boolean expected = Boolean.parseBoolean(testCase[2]);
            
            boolean actual = isSpecialGroupMatched(schoolName, specialGroupName, existingSchoolSpecialGroups);
            boolean passed = actual == expected;
            
            System.out.printf("学校: %-12s, 专业组: %-8s, 期望: %-5s, 实际: %-5s, 结果: %s%n", 
                    schoolName, specialGroupName, expected, actual, passed ? "✓" : "✗");
            
            if (passed) {
                passCount++;
            }
        }
        
        System.out.println();
        System.out.printf("测试总结: %d/%d 通过 (%.1f%%)%n", passCount, totalCount, (double)passCount/totalCount*100);
        
        // 测试专业组编号提取功能
        System.out.println();
        testExtractSpecialGroupCode();
    }
    
    public void testExtractSpecialGroupCode() {
        System.out.println("=== 专业组编号提取测试 ===");
        
        String[][] extractTestCases = {
            {"1093（W003）", "W003"},
            {"（003）", "003"},
            {"(W001)", "W001"},
            {"W002", "W002"},
            {"003", "003"},
            {"1094（L001）", "L001"},
            {"（）", null},
            {"", null},
            {null, null},
            {"无效格式", null}
        };
        
        int passCount = 0;
        int totalCount = extractTestCases.length;
        
        for (String[] testCase : extractTestCases) {
            String input = testCase[0];
            String expected = testCase[1];
            
            String actual = extractSpecialGroupCode(input);
            boolean passed = Objects.equals(actual, expected);
            
            System.out.printf("输入: %-12s, 期望: %-6s, 实际: %-6s, 结果: %s%n", 
                    input, expected, actual, passed ? "✓" : "✗");
            
            if (passed) {
                passCount++;
            }
        }
        
        System.out.println();
        System.out.printf("提取测试总结: %d/%d 通过 (%.1f%%)%n", passCount, totalCount, (double)passCount/totalCount*100);
    }
    
    /**
     * 检查专业组是否匹配
     */
    private boolean isSpecialGroupMatched(String schoolName, String specialGroupName, Set<String> existingSchoolSpecialGroups) {
        if (schoolName == null || specialGroupName == null || existingSchoolSpecialGroups.isEmpty()) {
            return false;
        }
        
        // 1. 直接匹配：检查完整的学校-专业组组合
        String directKey = schoolName + "::" + specialGroupName;
        if (existingSchoolSpecialGroups.contains(directKey)) {
            System.out.println("  -> 直接匹配成功: " + directKey);
            return true;
        }
        
        // 2. 提取专业组编号进行匹配
        String extractedGroupCode = extractSpecialGroupCode(specialGroupName);
        if (extractedGroupCode != null) {
            // 遍历已有的专业组，查找匹配的编号
            for (String existingKey : existingSchoolSpecialGroups) {
                if (existingKey.startsWith(schoolName + "::")) {
                    String existingSubjectGroup = existingKey.substring((schoolName + "::").length());
                    String existingGroupCode = extractSpecialGroupCode(existingSubjectGroup);
                    
                    if (isGroupCodeMatched(extractedGroupCode, existingGroupCode)) {
                        System.out.println("  -> 编号匹配成功: " + specialGroupName + " <-> " + existingSubjectGroup + ", 编号: " + extractedGroupCode + " <-> " + existingGroupCode);
                        return true;
                    }
                }
            }
        }
        
        System.out.println("  -> 匹配失败: 学校=" + schoolName + ", 专业组=" + specialGroupName + ", 提取编号=" + extractedGroupCode);
        return false;
    }
    
    /**
     * 从专业组字符串中提取专业组编号
     */
    private String extractSpecialGroupCode(String specialGroup) {
        if (specialGroup == null || specialGroup.trim().isEmpty()) {
            return null;
        }
        
        String trimmed = specialGroup.trim();
        
        // 1. 提取中文括号内的内容：（003）或（W003）
        Pattern chineseParenPattern = Pattern.compile("（([^）]+)）");
        Matcher chineseMatcher = chineseParenPattern.matcher(trimmed);
        if (chineseMatcher.find()) {
            String content = chineseMatcher.group(1);
            // 如果内容以字母开头（如W003），直接返回
            if (content.matches("[A-Za-z]\\d+")) {
                return content;
            }
            // 如果是纯数字（如003），返回数字部分
            if (content.matches("\\d+")) {
                return content;
            }
            return content;
        }
        
        // 2. 提取英文括号内的内容：(003)或(W003)
        Pattern englishParenPattern = Pattern.compile("\\(([^)]+)\\)");
        Matcher englishMatcher = englishParenPattern.matcher(trimmed);
        if (englishMatcher.find()) {
            String content = englishMatcher.group(1);
            if (content.matches("[A-Za-z]\\d+")) {
                return content;
            }
            if (content.matches("\\d+")) {
                return content;
            }
            return content;
        }
        
        // 3. 如果是字母+数字格式（如W003），直接返回
        if (trimmed.matches("[A-Za-z]\\d+")) {
            return trimmed;
        }
        
        // 4. 如果是纯数字格式（如003），直接返回
        if (trimmed.matches("\\d+")) {
            return trimmed;
        }
        
        // 5. 如果包含数字，尝试提取最后的数字部分
        Pattern numberPattern = Pattern.compile("([A-Za-z]?\\d+)$");
        Matcher numberMatcher = numberPattern.matcher(trimmed);
        if (numberMatcher.find()) {
            return numberMatcher.group(1);
        }
        
        return null;
    }
    
    /**
     * 检查两个专业组编号是否匹配
     */
    private boolean isGroupCodeMatched(String code1, String code2) {
        if (code1 == null || code2 == null) {
            return false;
        }
        
        // 1. 完全相同
        if (code1.equals(code2)) {
            return true;
        }
        
        // 2. 提取数字部分进行比较
        String number1 = extractNumberPart(code1);
        String number2 = extractNumberPart(code2);
        
        if (number1 != null && number2 != null && number1.equals(number2)) {
            System.out.println("    -> 数字部分匹配: " + code1 + " (" + number1 + ") <-> " + code2 + " (" + number2 + ")");
            return true;
        }
        
        return false;
    }
    
    /**
     * 从专业组编号中提取数字部分
     */
    private String extractNumberPart(String code) {
        if (code == null || code.trim().isEmpty()) {
            return null;
        }
        
        String trimmed = code.trim();
        
        // 如果是纯数字，直接返回
        if (trimmed.matches("\\d+")) {
            return trimmed;
        }
        
        // 如果是字母+数字格式，提取数字部分
        Pattern pattern = Pattern.compile("[A-Za-z]*(\\d+)");
        Matcher matcher = pattern.matcher(trimmed);
        if (matcher.find()) {
            return matcher.group(1);
        }
        
        return null;
    }
}